/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class SsoManagerService {

    /**
     * 用户通过前端授权服务器管理界面进行单点登录授权服务器添加
     * @returns any OK
     * @throws ApiError
     */
    public static async addSsoserver({
        ownerId,
        requestBody,
    }: {
        ownerId: string,
        requestBody?: {
            /**
             * 应用的鉴权协议，取值：
             * OAuth2.0
             */
            authProtocol: string,
            /**
             * 授权服务器名称
             */
            serverName: string,
            /**
             * 客户端ID。用于鉴权流程中识别应用的唯一标识
             */
            clientId: string,
            /**
             * 客户端密钥。
             */
            clientSecret: string,
            /**
             * 获取外部服务器授权的接口地址
             */
            authUrl: string,
            /**
             * 获取授权服务器令牌的接口地址
             */
            tokenUrl: string,
            /**
             * 获取授权服务器用户信息的接口地址
             */
            userUrl: string,
            /**
             * 描述
             */
            description?: string,
            /**
             * 授权服务器图标
             */
            icon: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 授权服务器信息入库成功后的ID编号
         */
        id: number,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/ssoserver/v1/${ownerId}/server-info`,
            body: requestBody,
        });

        __checkJsonSchema("addSsoserver", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 用户通过前端列举单点登录授权服务器
     * @returns any OK
     * @throws ApiError
     */
    public static async getSsoserverAuth({
        ownerId,
        requestBody,
    }: {
        ownerId: string,
        requestBody?: {
            /**
             * 授权服务器管理人ID
             */
            ownerId: string,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 单独登录授权服务器列表
         */
        ssoservers: Array<{
            /**
             * 授权服务器ID编号
             */
            id: number,
            /**
             * 应用的鉴权协议，取值：
             * OAuth2.0
             */
            authProtocol: string,
            /**
             * 授权服务器名称
             */
            serverName: string,
            /**
             * 客户端ID。用于鉴权流程中识别应用的唯一标识
             */
            clientId: string,
            /**
             * 客户端密钥。
             */
            clientSecret: string,
            /**
             * 获取外部服务器授权的接口地址
             */
            authUrl: string,
            /**
             * 获取授权服务器令牌的接口地址
             */
            tokenUrl: string,
            /**
             * 获取授权服务器用户信息的接口地址
             */
            userUrl: string,
            /**
             * 描述
             */
            description?: string,
            /**
             * 授权服务器图标
             */
            icon: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/ssoserver/v1/${ownerId}/server-info`,
            body: requestBody,
        });

        __checkJsonSchema("getSsoserverAuth", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端修改某单点登录授权服务器的基本信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async modSsoserverInfo({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: {
            /**
             * 授权服务器名称
             */
            serverName?: string,
            /**
             * 应用的鉴权协议，取值：
             * OAuth2.0
             */
            authProtocol?: string,
            /**
             * 获取外部服务器授权的接口地址
             */
            authUrl?: string,
            /**
             * 获取授权服务器令牌的接口地址
             */
            tokenUrl?: string,
            /**
             * 获取授权服务器用户信息的接口地址
             */
            userUrl?: string,
            /**
             * 描述
             */
            description?: string,
            /**
             * 授权服务器图标
             */
            icon?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/ssoserver/v1/${ownerId}/server-info/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("modSsoserverInfo", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端查询某个单点登录授权服务器
     * @returns any OK
     * @throws ApiError
     */
    public static async getSsoserverInfo({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: any,
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: string,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 单点登录授权服务器详细信息结构体，SSOServer结构体参考6.4.1.5构体说明。
         */
        ssoserver: any,
        /**
         * 授权服务器鉴权记录列表。
         */
        authRecords: Array<{
            /**
             * 用户客户端ID
             */
            clientId: string,
            /**
             * 用户名
             */
            username: string,
            /**
             * 操作时间
             */
            operateTime: string,
            /**
             * 操作结果
             */
            result: string,
            /**
             * 错误描述
             */
            erroDec?: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/ssoserver/v1/${ownerId}/server-info/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("getSsoserverInfo", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端删除某个单点登录授权服务器
     * @returns any Example response
     * @throws ApiError
     */
    public static async deleteSsoserver({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: any,
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'DELETE',
            path: `/ssoserver/v1/${ownerId}/server-info/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("deleteSsoserver", schemas, result);
        return result.body;
    }

    /**
     * 用户通过前端修改某单点登录授权服务器的凭证信息
     * @returns any Example response
     * @throws ApiError
     */
    public static async modSsoserverAuth({
        ownerId,
        id,
        requestBody,
    }: {
        ownerId: string,
        id: string,
        requestBody?: {
            /**
             * 客户端ID。用于鉴权流程中识别应用的唯一标识
             */
            clientId?: string,
            /**
             * 客户端密钥。
             */
            clientSecret?: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/ssoserver/v1/${ownerId}/server-authz/${id}`,
            body: requestBody,
        });

        __checkJsonSchema("modSsoserverAuth", schemas, result);
        return result.body;
    }

    /**
     * 用户进行单点登录
     * @returns any OK
     * @throws ApiError
     */
    public static async ssoclientLogin({
        userId,
        requestBody,
    }: {
        userId: string,
        requestBody?: {
            /**
             * 单点登录服务器ID
             */
            ssoServerId: number,
            /**
             * 单点登录账号ID
             */
            openId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 重定向登录Uri
         */
        redirectUri?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/ssoclient/v1/${userId}/login`,
            body: requestBody,
        });

        __checkJsonSchema("ssoclientLogin", schemas, result);
        return result.body;
    }

    /**
     * 用户基于授权码重新进行登录
     * @returns any Example response
     * @throws ApiError
     */
    public static async ssoclientAuth({
        userId,
        requestBody,
    }: {
        userId: string,
        requestBody?: {
            /**
             * 授权码
             */
            authCode: string,
            /**
             * 用户单点登录客户端ID
             */
            clientId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/ssoclient/v1/${userId}/auth`,
            body: requestBody,
        });

        __checkJsonSchema("ssoclientAuth", schemas, result);
        return result.body;
    }

    /**
     * 用户进行单点登出
     * @returns any OK
     * @throws ApiError
     */
    public static async ssoclientLogout({
        userId,
        requestBody,
    }: {
        userId: string,
        requestBody?: any,
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 重定向登录Uri
         */
        redirectUri?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/ssoclient/v1/${userId}/logout`,
            body: requestBody,
        });

        __checkJsonSchema("ssoclientLogout", schemas, result);
        return result.body;
    }

}